Computer systems can be generally divided into four components: the hardware level, the application programs, the operating system, and the user level. The hardware level provides the basic computing resources and includes a central processing unit (CPU), memory, and input/output (I/O) devices. The application programs, such as database systems and business programs, define the ways in which these resources are used to solve the computing problems of users. The operating system (OS) controls and coordinates the use of the hardware among the various application programs for the various users. In doing so, one goal of the OS is to make the computer system convenient to use. A secondary goal is to use the hardware in an efficient manner.
The Unix operating system is one example of an OS that is currently used by many enterprise computer systems. Solaris™ (commercially available by Sun Microsystems, Inc., a corporation in Santa Clara, Calif.) is a multitasking, multiprocessing OS providing an enterprise-wide Unix environment. Unix was designed to be a simple time-sharing system, with a hierarchical file system, which supported multiple processes. A process is the execution of a program and may include a pattern of bytes that the CPU interprets as machine instructions (text), data, and a stack. A stack defines a set of hardware registers or a reserved amount of main memory that is used for arithmetic calculations.
Unix includes two separable parts: the system programs and the kernel. Systems programs may include system libraries, compilers, interpreters, shells, and other such programs, which provide useful functions to the user. The kernel is the central controlling program that provides basic system facilities. The kernel creates and manages processes, provides functions to access file-systems, and supplies communications facilities. The kernel is the only part of Unix that a user cannot replace. The kernel also provides the file system, CPU scheduling, memory management, and other operating-system functions by responding to “system-calls.” Conceptually, the kernel is situated between the hardware and the user level. System calls are the means for the programmer to communicate with the kernel.
FIG. 1 shows a block diagram of a conventional computer system (100) having a CPU (110), file system (120), memory (160), system controller (150), and applications (170), intercoupled by a bus (101). Further, the file system (120) reads and writes to a block storage device (199) (e.g., a disc) and an Input/Output (I/O) device (130) via one or more device drivers (195).
The prior art system (100) shown in FIG. 1 employs a distributed memory mapping scheme in which physical memory and I/O of the computer system (100) is mapped with hardware descriptors. The computer system (100) implements a shared resource environment which allows such system resources as memory (160) and file system (120) to be shared between applications processes in applications (170). The application processes are able to access virtual memory in memory (160) sometimes with the use of a memory controller (140). The multiple and varied applications (170) often attempt simultaneous access the file-system (120) in the shared environment of the computer system (100).
As distributed systems become prevalent, CPU (or processor) speed, network speed, Random Access Memory (RAM) size, and storage disk size increase along with access to these devices. The interface between the file system (120) and memory (160) therefore becomes important.
Memory requirements of the computer system (100) frequently cannot be met with a single memory device. Often, several memory devices are interconnected to form a memory system. In a memory system, capacity is expanded by increasing the number of words (i.e., multiplexing outputs from two or more memory devices) or by increasing the word length (i.e., placing the outputs of two or more memory devices in parallel) above an attainable single memory device. A memory system with an increased number of words requires address expansion; the memory system requires expanding the number of address bits to which the memory system responds. The number of address bits that a microprocessor provides dictates its memory address space or the range of memory locations it can directly address. Depending upon the size of the memory system, external address decoding logic, in addition to the memory's inputs may also be required for address expansion.
RAM is typically the main memory in many computer systems. When an application (170) initially executes, the application (170) is loaded into RAM, generally from the block storage (199) and the operating system then directs the application (170) to begin execution. Program data also loads into the computer's RAM. As changes are made in the data, the contents of the RAM are altered, and when the user finishes with the application, the revised data is copied back to the block storage (199).
Read Only Memory (ROM) is the part of memory where the basic input/output system (BIOS) of the computer typically resides. The BIOS is the interface between the computer hardware and the operating system and applications software. Under normal circumstances, one cannot write to ROM. The computer system (100) includes several memory types (e.g., RAM, ROM, etc.) that access different locations in the memory (160). And in order to have a cohesive memory access to the various applications (170) that execute in the computer system (100), the memory (160) in the computer system (100) typically has a number of memory descriptors, as described in FIG. 2.
FIG. 2 shows a block diagram of a memory descriptor scheme of a distributed computer system. A computer system has unique specific memory descriptors (or page table entries) (214, 215, 216) associated with each instance of an application (170) that access a different type of memory (e.g., Memory 1 (220), Memory 2 (221), Memory 3 (223)). The memory descriptors (214, 215, 216) that define relationships between the applications (170) and main memory identifying specific address ranges (i.e., memory segments (210, 211, 212)) for specific purposes.
Many modern computer systems perform a variety of functions using peripheral devices including block devices, such as disc drives. For the computer's OS to utilize peripheral devices, the OS and the peripheral devices are effectively linked. Peripheral devices and the OS are typically linked by device drivers, which are accessed by the file system using a strategy routine. Device drivers receive I/O commands from file systems associated with the OS. To send such I/O commands to the device drivers, a file system typically reads into or writes out of memory. Thus, with the conventional multiplicity of memory descriptors discussed above, file systems are required to manipulate multiple representations of RAM in order to initiate I/O commands to device drivers.
Conventionally, the memory that a file system needs to read into or write out of takes the form of a buffer or array of buffers (e.g., in kernel or user address space), a page, or a page list. Some forms of direction, such as flags, are used to read a file into or write a file from a user buffer or other memory structure. A buffer read/write (“bread/bwrite”) routine can be used to read/write a file from/into a kernel buffer. Similarly, memory page I/O (“pageio”) can be used with pages and page lists, and a user I/O (“uio”) routine with user buffers. Thus, the file system is required to procure and act on a sizable amount of information regarding the memory to accomplish interactions therewith.
If memory is changed in some way, such as by abstracting or by enlarging the specified page size (for instance, changing from an 8 KByte to a 64 KByte page size), the file system may have corresponding problems. Where memory is abstracted, accessory functions would have to be added, which increases complexity. A routine can conventionally handle memory abstractions by decomposing the abstraction for the file system to access pieces to construct buffer headers to go to a strategy routine. However, this adds complexity, adds task requirements to the file system, and may be slow and inefficient, requiring inordinately intricate code. Alternatively, all device drivers in use with a computer deploying memory abstraction would have to be modified to accept the selected abstraction.